﻿#region Using directives

using System;
using System.Collections.Generic;
using System.Configuration;
using System.Configuration.Provider;
using System.Web.Configuration;
using System.Web;
using InvoiceChecking.Entities;
using InvoiceChecking.Data;
using InvoiceChecking.Data.Bases;

#endregion

namespace InvoiceChecking.Data
{
	/// <summary>
	/// This class represents the Data source repository and gives access to all the underlying providers.
	/// </summary>
	[CLSCompliant(true)]
	public sealed class DataRepository 
	{
		private static volatile NetTiersProvider _provider = null;
        private static volatile NetTiersProviderCollection _providers = null;
		private static volatile NetTiersServiceSection _section = null;
		private static volatile Configuration _config = null;
        
        private static object SyncRoot = new object();
				
		private DataRepository()
		{
		}
		
		#region Public LoadProvider
		/// <summary>
        /// Enables the DataRepository to programatically create and 
        /// pass in a <c>NetTiersProvider</c> during runtime.
        /// </summary>
        /// <param name="provider">An instatiated NetTiersProvider.</param>
        public static void LoadProvider(NetTiersProvider provider)
        {
			LoadProvider(provider, false);
        }
		
		/// <summary>
        /// Enables the DataRepository to programatically create and 
        /// pass in a <c>NetTiersProvider</c> during runtime.
        /// </summary>
        /// <param name="provider">An instatiated NetTiersProvider.</param>
        /// <param name="setAsDefault">ability to set any valid provider as the default provider for the DataRepository.</param>
		public static void LoadProvider(NetTiersProvider provider, bool setAsDefault)
        {
            if (provider == null)
                throw new ArgumentNullException("provider");

            if (_providers == null)
			{
				lock(SyncRoot)
				{
            		if (_providers == null)
						_providers = new NetTiersProviderCollection();
				}
			}
			
            if (_providers[provider.Name] == null)
            {
                lock (_providers.SyncRoot)
                {
                    _providers.Add(provider);
                }
            }

            if (_provider == null || setAsDefault)
            {
                lock (SyncRoot)
                {
                    if(_provider == null || setAsDefault)
                         _provider = provider;
                }
            }
        }
		#endregion 
		
		///<summary>
		/// Configuration based provider loading, will load the providers on first call.
		///</summary>
		private static void LoadProviders()
        {
            // Avoid claiming lock if providers are already loaded
            if (_provider == null)
            {
                lock (SyncRoot)
                {
                    // Do this again to make sure _provider is still null
                    if (_provider == null)
                    {
                        // Load registered providers and point _provider to the default provider
                        _providers = new NetTiersProviderCollection();

                        ProvidersHelper.InstantiateProviders(NetTiersSection.Providers, _providers, typeof(NetTiersProvider));
						_provider = _providers[NetTiersSection.DefaultProvider];

                        if (_provider == null)
                        {
                            throw new ProviderException("Unable to load default NetTiersProvider");
                        }
                    }
                }
            }
        }

		/// <summary>
        /// Gets the provider.
        /// </summary>
        /// <value>The provider.</value>
        public static NetTiersProvider Provider
        {
            get { LoadProviders(); return _provider; }
        }

		/// <summary>
        /// Gets the provider collection.
        /// </summary>
        /// <value>The providers.</value>
        public static NetTiersProviderCollection Providers
        {
            get { LoadProviders(); return _providers; }
        }
		
		/// <summary>
		/// Creates a new <see cref="TransactionManager"/> instance from the current datasource.
		/// </summary>
		/// <returns></returns>
		public TransactionManager CreateTransaction()
		{
			return _provider.CreateTransaction();
		}

		#region Configuration

		/// <summary>
		/// Gets a reference to the configured NetTiersServiceSection object.
		/// </summary>
		public static NetTiersServiceSection NetTiersSection
		{
			get
			{
				// Try to get a reference to the default <netTiersService> section
				_section = WebConfigurationManager.GetSection("netTiersService") as NetTiersServiceSection;

				if ( _section == null )
				{
					// otherwise look for section based on the assembly name
					_section = WebConfigurationManager.GetSection("InvoiceChecking.Data") as NetTiersServiceSection;
				}

				#region Design-Time Support

				if ( _section == null )
				{
					// lastly, try to find the specific NetTiersServiceSection for this assembly
					foreach ( ConfigurationSection temp in Configuration.Sections )
					{
						if ( temp is NetTiersServiceSection )
						{
							_section = temp as NetTiersServiceSection;
							break;
						}
					}
				}

				#endregion Design-Time Support
				
				if ( _section == null )
				{
					throw new ProviderException("Unable to load NetTiersServiceSection");
				}

				return _section;
			}
		}

		#region Design-Time Support

		/// <summary>
		/// Gets a reference to the application configuration object.
		/// </summary>
		public static Configuration Configuration
		{
			get
			{
				if ( _config == null )
				{
					// load specific config file
					if ( HttpContext.Current != null )
					{
						_config = WebConfigurationManager.OpenWebConfiguration("~");
					}
					else
					{
						String configFile = AppDomain.CurrentDomain.SetupInformation.ConfigurationFile.Replace(".config", "").Replace(".temp", "");

						// check for design mode
						if ( configFile.ToLower().Contains("devenv.exe") )
						{
							_config = GetDesignTimeConfig();
						}
						else
						{
							_config = ConfigurationManager.OpenExeConfiguration(configFile);
						}
					}
				}

				return _config;
			}
		}

		private static Configuration GetDesignTimeConfig()
		{
			ExeConfigurationFileMap configMap = null;
			Configuration config = null;
			String path = null;

			// Get an instance of the currently running Visual Studio IDE.
			EnvDTE80.DTE2 dte = (EnvDTE80.DTE2) System.Runtime.InteropServices.Marshal.GetActiveObject("VisualStudio.DTE.9.0");
			
			if ( dte != null )
			{
				dte.SuppressUI = true;

				EnvDTE.ProjectItem item = dte.Solution.FindProjectItem("web.config");
				if ( item != null )
				{
					if (!item.ContainingProject.FullName.ToLower().StartsWith("http:"))
               {
                  System.IO.FileInfo info = new System.IO.FileInfo(item.ContainingProject.FullName);
                  path = String.Format("{0}\\{1}", info.Directory.FullName, item.Name);
                  configMap = new ExeConfigurationFileMap();
                  configMap.ExeConfigFilename = path;
               }
               else
               {
                  configMap = new ExeConfigurationFileMap();
                  configMap.ExeConfigFilename = item.get_FileNames(0);
               }}

				/*
				Array projects = (Array) dte2.ActiveSolutionProjects;
				EnvDTE.Project project = (EnvDTE.Project) projects.GetValue(0);
				System.IO.FileInfo info;

				foreach ( EnvDTE.ProjectItem item in project.ProjectItems )
				{
					if ( String.Compare(item.Name, "web.config", true) == 0 )
					{
						info = new System.IO.FileInfo(project.FullName);
						path = String.Format("{0}\\{1}", info.Directory.FullName, item.Name);
						configMap = new ExeConfigurationFileMap();
						configMap.ExeConfigFilename = path;
						break;
					}
				}
				*/
			}

			config = ConfigurationManager.OpenMappedExeConfiguration(configMap, ConfigurationUserLevel.None);
			return config;
		}

		#endregion Design-Time Support

		#endregion Configuration

		#region Connections

		/// <summary>
		/// Gets a reference to the ConnectionStringSettings collection.
		/// </summary>
		public static ConnectionStringSettingsCollection ConnectionStrings
		{
			get
			{
					// use default ConnectionStrings if _section has already been discovered
					if ( _config == null && _section != null )
					{
						return WebConfigurationManager.ConnectionStrings;
					}
					
					return Configuration.ConnectionStrings.ConnectionStrings;
			}
		}

		// dictionary of connection providers
		private static Dictionary<String, ConnectionProvider> _connections;

		/// <summary>
		/// Gets the dictionary of connection providers.
		/// </summary>
		public static Dictionary<String, ConnectionProvider> Connections
		{
			get
			{
				if ( _connections == null )
				{
					lock (SyncRoot)
                	{
						if (_connections == null)
						{
							_connections = new Dictionary<String, ConnectionProvider>();
		
							// add a connection provider for each configured connection string
							foreach ( ConnectionStringSettings conn in ConnectionStrings )
							{
								_connections.Add(conn.Name, new ConnectionProvider(conn.Name, conn.ConnectionString));
							}
						}
					}
				}

				return _connections;
			}
		}

		/// <summary>
		/// Adds the specified connection string to the map of connection strings.
		/// </summary>
		/// <param name="connectionStringName">The connection string name.</param>
		/// <param name="connectionString">The provider specific connection information.</param>
		public static void AddConnection(String connectionStringName, String connectionString)
		{
			lock (SyncRoot)
            {
				Connections.Remove(connectionStringName);
				ConnectionProvider connection = new ConnectionProvider(connectionStringName, connectionString);
				Connections.Add(connectionStringName, connection);
			}
		}

		/// <summary>
		/// Provides ability to switch connection string at runtime.
		/// </summary>
		public sealed class ConnectionProvider
		{
			private NetTiersProvider _provider;
			private NetTiersProviderCollection _providers;
			private String _connectionStringName;
			private String _connectionString;


			/// <summary>
			/// Initializes a new instance of the ConnectionProvider class.
			/// </summary>
			/// <param name="connectionStringName">The connection string name.</param>
			/// <param name="connectionString">The provider specific connection information.</param>
			public ConnectionProvider(String connectionStringName, String connectionString)
			{
				_connectionString = connectionString;
				_connectionStringName = connectionStringName;
			}

			/// <summary>
			/// Gets the provider.
			/// </summary>
			public NetTiersProvider Provider
			{
				get { LoadProviders(); return _provider; }
			}

			/// <summary>
			/// Gets the provider collection.
			/// </summary>
			public NetTiersProviderCollection Providers
			{
				get { LoadProviders(); return _providers; }
			}

			/// <summary>
			/// Instantiates the configured providers based on the supplied connection string.
			/// </summary>
			private void LoadProviders()
			{
				DataRepository.LoadProviders();

				// Avoid claiming lock if providers are already loaded
				if ( _providers == null )
				{
					lock ( SyncRoot )
					{
						// Do this again to make sure _provider is still null
						if ( _providers == null )
						{
							// apply connection information to each provider
							for ( int i = 0; i < NetTiersSection.Providers.Count; i++ )
							{
								NetTiersSection.Providers[i].Parameters["connectionStringName"] = _connectionStringName;
								// remove previous connection string, if any
								NetTiersSection.Providers[i].Parameters.Remove("connectionString");

								if ( !String.IsNullOrEmpty(_connectionString) )
								{
									NetTiersSection.Providers[i].Parameters["connectionString"] = _connectionString;
								}
							}

							// Load registered providers and point _provider to the default provider
							_providers = new NetTiersProviderCollection();

							ProvidersHelper.InstantiateProviders(NetTiersSection.Providers, _providers, typeof(NetTiersProvider));
							_provider = _providers[NetTiersSection.DefaultProvider];
						}
					}
				}
			}
		}

		#endregion Connections

		#region Static properties
		
		#region AbAccountCodeProvider

		///<summary>
		/// Gets the current instance of the Data Access Logic Component for the <see cref="AbAccountCode"/> business entity.
		/// It exposes CRUD methods as well as selecting on index, foreign keys and custom stored procedures.
		///</summary>
		public static AbAccountCodeProviderBase AbAccountCodeProvider
		{
			get 
			{
				LoadProviders();
				return _provider.AbAccountCodeProvider;
			}
		}
		
		#endregion
		
		#region PaymentAccountProvider

		///<summary>
		/// Gets the current instance of the Data Access Logic Component for the <see cref="PaymentAccount"/> business entity.
		/// It exposes CRUD methods as well as selecting on index, foreign keys and custom stored procedures.
		///</summary>
		public static PaymentAccountProviderBase PaymentAccountProvider
		{
			get 
			{
				LoadProviders();
				return _provider.PaymentAccountProvider;
			}
		}
		
		#endregion
		
		#region PaymentTypeProvider

		///<summary>
		/// Gets the current instance of the Data Access Logic Component for the <see cref="PaymentType"/> business entity.
		/// It exposes CRUD methods as well as selecting on index, foreign keys and custom stored procedures.
		///</summary>
		public static PaymentTypeProviderBase PaymentTypeProvider
		{
			get 
			{
				LoadProviders();
				return _provider.PaymentTypeProvider;
			}
		}
		
		#endregion
		
		#region PaymentProvider

		///<summary>
		/// Gets the current instance of the Data Access Logic Component for the <see cref="Payment"/> business entity.
		/// It exposes CRUD methods as well as selecting on index, foreign keys and custom stored procedures.
		///</summary>
		public static PaymentProviderBase PaymentProvider
		{
			get 
			{
				LoadProviders();
				return _provider.PaymentProvider;
			}
		}
		
		#endregion
		
		#region SunReferenceProvider

		///<summary>
		/// Gets the current instance of the Data Access Logic Component for the <see cref="SunReference"/> business entity.
		/// It exposes CRUD methods as well as selecting on index, foreign keys and custom stored procedures.
		///</summary>
		public static SunReferenceProviderBase SunReferenceProvider
		{
			get 
			{
				LoadProviders();
				return _provider.SunReferenceProvider;
			}
		}
		
		#endregion
		
		#region VoidReasonProvider

		///<summary>
		/// Gets the current instance of the Data Access Logic Component for the <see cref="VoidReason"/> business entity.
		/// It exposes CRUD methods as well as selecting on index, foreign keys and custom stored procedures.
		///</summary>
		public static VoidReasonProviderBase VoidReasonProvider
		{
			get 
			{
				LoadProviders();
				return _provider.VoidReasonProvider;
			}
		}
		
		#endregion
		
		#region NewRevenueVnProvider

		///<summary>
		/// Gets the current instance of the Data Access Logic Component for the <see cref="NewRevenueVn"/> business entity.
		/// It exposes CRUD methods as well as selecting on index, foreign keys and custom stored procedures.
		///</summary>
		public static NewRevenueVnProviderBase NewRevenueVnProvider
		{
			get 
			{
				LoadProviders();
				return _provider.NewRevenueVnProvider;
			}
		}
		
		#endregion
		
		#region PaymentDetailProvider

		///<summary>
		/// Gets the current instance of the Data Access Logic Component for the <see cref="PaymentDetail"/> business entity.
		/// It exposes CRUD methods as well as selecting on index, foreign keys and custom stored procedures.
		///</summary>
		public static PaymentDetailProviderBase PaymentDetailProvider
		{
			get 
			{
				LoadProviders();
				return _provider.PaymentDetailProvider;
			}
		}
		
		#endregion
		
		#region NewRevenueProvider

		///<summary>
		/// Gets the current instance of the Data Access Logic Component for the <see cref="NewRevenue"/> business entity.
		/// It exposes CRUD methods as well as selecting on index, foreign keys and custom stored procedures.
		///</summary>
		public static NewRevenueProviderBase NewRevenueProvider
		{
			get 
			{
				LoadProviders();
				return _provider.NewRevenueProvider;
			}
		}
		
		#endregion
		
		#region CreditCardProvider

		///<summary>
		/// Gets the current instance of the Data Access Logic Component for the <see cref="CreditCard"/> business entity.
		/// It exposes CRUD methods as well as selecting on index, foreign keys and custom stored procedures.
		///</summary>
		public static CreditCardProviderBase CreditCardProvider
		{
			get 
			{
				LoadProviders();
				return _provider.CreditCardProvider;
			}
		}
		
		#endregion
		
		#region JournalVoucherTypeProvider

		///<summary>
		/// Gets the current instance of the Data Access Logic Component for the <see cref="JournalVoucherType"/> business entity.
		/// It exposes CRUD methods as well as selecting on index, foreign keys and custom stored procedures.
		///</summary>
		public static JournalVoucherTypeProviderBase JournalVoucherTypeProvider
		{
			get 
			{
				LoadProviders();
				return _provider.JournalVoucherTypeProvider;
			}
		}
		
		#endregion
		
		#region DailyTransProvider

		///<summary>
		/// Gets the current instance of the Data Access Logic Component for the <see cref="DailyTrans"/> business entity.
		/// It exposes CRUD methods as well as selecting on index, foreign keys and custom stored procedures.
		///</summary>
		public static DailyTransProviderBase DailyTransProvider
		{
			get 
			{
				LoadProviders();
				return _provider.DailyTransProvider;
			}
		}
		
		#endregion
		
		#region CheckInvoiceProvider

		///<summary>
		/// Gets the current instance of the Data Access Logic Component for the <see cref="CheckInvoice"/> business entity.
		/// It exposes CRUD methods as well as selecting on index, foreign keys and custom stored procedures.
		///</summary>
		public static CheckInvoiceProviderBase CheckInvoiceProvider
		{
			get 
			{
				LoadProviders();
				return _provider.CheckInvoiceProvider;
			}
		}
		
		#endregion
		
		#region JournalVoucherProvider

		///<summary>
		/// Gets the current instance of the Data Access Logic Component for the <see cref="JournalVoucher"/> business entity.
		/// It exposes CRUD methods as well as selecting on index, foreign keys and custom stored procedures.
		///</summary>
		public static JournalVoucherProviderBase JournalVoucherProvider
		{
			get 
			{
				LoadProviders();
				return _provider.JournalVoucherProvider;
			}
		}
		
		#endregion
		
		#region InvoiceCheckingUserProvider

		///<summary>
		/// Gets the current instance of the Data Access Logic Component for the <see cref="InvoiceCheckingUser"/> business entity.
		/// It exposes CRUD methods as well as selecting on index, foreign keys and custom stored procedures.
		///</summary>
		public static InvoiceCheckingUserProviderBase InvoiceCheckingUserProvider
		{
			get 
			{
				LoadProviders();
				return _provider.InvoiceCheckingUserProvider;
			}
		}
		
		#endregion
		
		#region TcodeProvider

		///<summary>
		/// Gets the current instance of the Data Access Logic Component for the <see cref="Tcode"/> business entity.
		/// It exposes CRUD methods as well as selecting on index, foreign keys and custom stored procedures.
		///</summary>
		public static TcodeProviderBase TcodeProvider
		{
			get 
			{
				LoadProviders();
				return _provider.TcodeProvider;
			}
		}
		
		#endregion
		
		#region JournalDetailsProvider

		///<summary>
		/// Gets the current instance of the Data Access Logic Component for the <see cref="JournalDetails"/> business entity.
		/// It exposes CRUD methods as well as selecting on index, foreign keys and custom stored procedures.
		///</summary>
		public static JournalDetailsProviderBase JournalDetailsProvider
		{
			get 
			{
				LoadProviders();
				return _provider.JournalDetailsProvider;
			}
		}
		
		#endregion
		
		
		#region AllInvoiceProvider
		
		///<summary>
		/// Gets the current instance of the Data Access Logic Component for the <see cref="AllInvoice"/> business entity.
		/// It exposes CRUD methods as well as selecting on index, foreign keys and custom stored procedures.
		///</summary>
		public static AllInvoiceProviderBase AllInvoiceProvider
		{
			get 
			{
				LoadProviders();
				return _provider.AllInvoiceProvider;
			}
		}
		
		#endregion
		
		#region SunAccountCodeProvider
		
		///<summary>
		/// Gets the current instance of the Data Access Logic Component for the <see cref="SunAccountCode"/> business entity.
		/// It exposes CRUD methods as well as selecting on index, foreign keys and custom stored procedures.
		///</summary>
		public static SunAccountCodeProviderBase SunAccountCodeProvider
		{
			get 
			{
				LoadProviders();
				return _provider.SunAccountCodeProvider;
			}
		}
		
		#endregion
		
		#region SunInvoiceProvider
		
		///<summary>
		/// Gets the current instance of the Data Access Logic Component for the <see cref="SunInvoice"/> business entity.
		/// It exposes CRUD methods as well as selecting on index, foreign keys and custom stored procedures.
		///</summary>
		public static SunInvoiceProviderBase SunInvoiceProvider
		{
			get 
			{
				LoadProviders();
				return _provider.SunInvoiceProvider;
			}
		}
		
		#endregion
		
		#region SunJournalVoucherProvider
		
		///<summary>
		/// Gets the current instance of the Data Access Logic Component for the <see cref="SunJournalVoucher"/> business entity.
		/// It exposes CRUD methods as well as selecting on index, foreign keys and custom stored procedures.
		///</summary>
		public static SunJournalVoucherProviderBase SunJournalVoucherProvider
		{
			get 
			{
				LoadProviders();
				return _provider.SunJournalVoucherProvider;
			}
		}
		
		#endregion
		
		#region SunPaymentVoucherProvider
		
		///<summary>
		/// Gets the current instance of the Data Access Logic Component for the <see cref="SunPaymentVoucher"/> business entity.
		/// It exposes CRUD methods as well as selecting on index, foreign keys and custom stored procedures.
		///</summary>
		public static SunPaymentVoucherProviderBase SunPaymentVoucherProvider
		{
			get 
			{
				LoadProviders();
				return _provider.SunPaymentVoucherProvider;
			}
		}
		
		#endregion
		
		#region SunReportPrintingProvider
		
		///<summary>
		/// Gets the current instance of the Data Access Logic Component for the <see cref="SunReportPrinting"/> business entity.
		/// It exposes CRUD methods as well as selecting on index, foreign keys and custom stored procedures.
		///</summary>
		public static SunReportPrintingProviderBase SunReportPrintingProvider
		{
			get 
			{
				LoadProviders();
				return _provider.SunReportPrintingProvider;
			}
		}
		
		#endregion
		
		#region VrProcPharRevProvider
		
		///<summary>
		/// Gets the current instance of the Data Access Logic Component for the <see cref="VrProcPharRev"/> business entity.
		/// It exposes CRUD methods as well as selecting on index, foreign keys and custom stored procedures.
		///</summary>
		public static VrProcPharRevProviderBase VrProcPharRevProvider
		{
			get 
			{
				LoadProviders();
				return _provider.VrProcPharRevProvider;
			}
		}
		
		#endregion
		
		#endregion
	}
	
	#region Query/Filters
		
	#region AbAccountCodeFilters
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="SqlFilterBuilder&lt;EntityColumn&gt;"/> class
	/// that is used exclusively with a <see cref="AbAccountCode"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class AbAccountCodeFilters : AbAccountCodeFilterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the AbAccountCodeFilters class.
		/// </summary>
		public AbAccountCodeFilters() : base() { }

		/// <summary>
		/// Initializes a new instance of the AbAccountCodeFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public AbAccountCodeFilters(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the AbAccountCodeFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public AbAccountCodeFilters(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion AbAccountCodeFilters
	
	#region AbAccountCodeQuery
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="AbAccountCodeParameterBuilder"/> class
	/// that is used exclusively with a <see cref="AbAccountCode"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class AbAccountCodeQuery : AbAccountCodeParameterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the AbAccountCodeQuery class.
		/// </summary>
		public AbAccountCodeQuery() : base() { }

		/// <summary>
		/// Initializes a new instance of the AbAccountCodeQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public AbAccountCodeQuery(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the AbAccountCodeQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public AbAccountCodeQuery(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion AbAccountCodeQuery
		
	#region PaymentAccountFilters
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="SqlFilterBuilder&lt;EntityColumn&gt;"/> class
	/// that is used exclusively with a <see cref="PaymentAccount"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class PaymentAccountFilters : PaymentAccountFilterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the PaymentAccountFilters class.
		/// </summary>
		public PaymentAccountFilters() : base() { }

		/// <summary>
		/// Initializes a new instance of the PaymentAccountFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public PaymentAccountFilters(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the PaymentAccountFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public PaymentAccountFilters(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion PaymentAccountFilters
	
	#region PaymentAccountQuery
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="PaymentAccountParameterBuilder"/> class
	/// that is used exclusively with a <see cref="PaymentAccount"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class PaymentAccountQuery : PaymentAccountParameterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the PaymentAccountQuery class.
		/// </summary>
		public PaymentAccountQuery() : base() { }

		/// <summary>
		/// Initializes a new instance of the PaymentAccountQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public PaymentAccountQuery(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the PaymentAccountQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public PaymentAccountQuery(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion PaymentAccountQuery
		
	#region PaymentTypeFilters
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="SqlFilterBuilder&lt;EntityColumn&gt;"/> class
	/// that is used exclusively with a <see cref="PaymentType"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class PaymentTypeFilters : PaymentTypeFilterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the PaymentTypeFilters class.
		/// </summary>
		public PaymentTypeFilters() : base() { }

		/// <summary>
		/// Initializes a new instance of the PaymentTypeFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public PaymentTypeFilters(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the PaymentTypeFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public PaymentTypeFilters(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion PaymentTypeFilters
	
	#region PaymentTypeQuery
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="PaymentTypeParameterBuilder"/> class
	/// that is used exclusively with a <see cref="PaymentType"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class PaymentTypeQuery : PaymentTypeParameterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the PaymentTypeQuery class.
		/// </summary>
		public PaymentTypeQuery() : base() { }

		/// <summary>
		/// Initializes a new instance of the PaymentTypeQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public PaymentTypeQuery(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the PaymentTypeQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public PaymentTypeQuery(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion PaymentTypeQuery
		
	#region PaymentFilters
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="SqlFilterBuilder&lt;EntityColumn&gt;"/> class
	/// that is used exclusively with a <see cref="Payment"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class PaymentFilters : PaymentFilterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the PaymentFilters class.
		/// </summary>
		public PaymentFilters() : base() { }

		/// <summary>
		/// Initializes a new instance of the PaymentFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public PaymentFilters(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the PaymentFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public PaymentFilters(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion PaymentFilters
	
	#region PaymentQuery
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="PaymentParameterBuilder"/> class
	/// that is used exclusively with a <see cref="Payment"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class PaymentQuery : PaymentParameterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the PaymentQuery class.
		/// </summary>
		public PaymentQuery() : base() { }

		/// <summary>
		/// Initializes a new instance of the PaymentQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public PaymentQuery(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the PaymentQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public PaymentQuery(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion PaymentQuery
		
	#region SunReferenceFilters
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="SqlFilterBuilder&lt;EntityColumn&gt;"/> class
	/// that is used exclusively with a <see cref="SunReference"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class SunReferenceFilters : SunReferenceFilterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the SunReferenceFilters class.
		/// </summary>
		public SunReferenceFilters() : base() { }

		/// <summary>
		/// Initializes a new instance of the SunReferenceFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public SunReferenceFilters(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the SunReferenceFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public SunReferenceFilters(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion SunReferenceFilters
	
	#region SunReferenceQuery
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="SunReferenceParameterBuilder"/> class
	/// that is used exclusively with a <see cref="SunReference"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class SunReferenceQuery : SunReferenceParameterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the SunReferenceQuery class.
		/// </summary>
		public SunReferenceQuery() : base() { }

		/// <summary>
		/// Initializes a new instance of the SunReferenceQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public SunReferenceQuery(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the SunReferenceQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public SunReferenceQuery(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion SunReferenceQuery
		
	#region VoidReasonFilters
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="SqlFilterBuilder&lt;EntityColumn&gt;"/> class
	/// that is used exclusively with a <see cref="VoidReason"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class VoidReasonFilters : VoidReasonFilterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the VoidReasonFilters class.
		/// </summary>
		public VoidReasonFilters() : base() { }

		/// <summary>
		/// Initializes a new instance of the VoidReasonFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public VoidReasonFilters(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the VoidReasonFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public VoidReasonFilters(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion VoidReasonFilters
	
	#region VoidReasonQuery
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="VoidReasonParameterBuilder"/> class
	/// that is used exclusively with a <see cref="VoidReason"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class VoidReasonQuery : VoidReasonParameterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the VoidReasonQuery class.
		/// </summary>
		public VoidReasonQuery() : base() { }

		/// <summary>
		/// Initializes a new instance of the VoidReasonQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public VoidReasonQuery(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the VoidReasonQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public VoidReasonQuery(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion VoidReasonQuery
		
	#region NewRevenueVnFilters
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="SqlFilterBuilder&lt;EntityColumn&gt;"/> class
	/// that is used exclusively with a <see cref="NewRevenueVn"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class NewRevenueVnFilters : NewRevenueVnFilterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the NewRevenueVnFilters class.
		/// </summary>
		public NewRevenueVnFilters() : base() { }

		/// <summary>
		/// Initializes a new instance of the NewRevenueVnFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public NewRevenueVnFilters(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the NewRevenueVnFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public NewRevenueVnFilters(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion NewRevenueVnFilters
	
	#region NewRevenueVnQuery
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="NewRevenueVnParameterBuilder"/> class
	/// that is used exclusively with a <see cref="NewRevenueVn"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class NewRevenueVnQuery : NewRevenueVnParameterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the NewRevenueVnQuery class.
		/// </summary>
		public NewRevenueVnQuery() : base() { }

		/// <summary>
		/// Initializes a new instance of the NewRevenueVnQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public NewRevenueVnQuery(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the NewRevenueVnQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public NewRevenueVnQuery(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion NewRevenueVnQuery
		
	#region PaymentDetailFilters
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="SqlFilterBuilder&lt;EntityColumn&gt;"/> class
	/// that is used exclusively with a <see cref="PaymentDetail"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class PaymentDetailFilters : PaymentDetailFilterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the PaymentDetailFilters class.
		/// </summary>
		public PaymentDetailFilters() : base() { }

		/// <summary>
		/// Initializes a new instance of the PaymentDetailFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public PaymentDetailFilters(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the PaymentDetailFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public PaymentDetailFilters(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion PaymentDetailFilters
	
	#region PaymentDetailQuery
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="PaymentDetailParameterBuilder"/> class
	/// that is used exclusively with a <see cref="PaymentDetail"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class PaymentDetailQuery : PaymentDetailParameterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the PaymentDetailQuery class.
		/// </summary>
		public PaymentDetailQuery() : base() { }

		/// <summary>
		/// Initializes a new instance of the PaymentDetailQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public PaymentDetailQuery(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the PaymentDetailQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public PaymentDetailQuery(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion PaymentDetailQuery
		
	#region NewRevenueFilters
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="SqlFilterBuilder&lt;EntityColumn&gt;"/> class
	/// that is used exclusively with a <see cref="NewRevenue"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class NewRevenueFilters : NewRevenueFilterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the NewRevenueFilters class.
		/// </summary>
		public NewRevenueFilters() : base() { }

		/// <summary>
		/// Initializes a new instance of the NewRevenueFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public NewRevenueFilters(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the NewRevenueFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public NewRevenueFilters(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion NewRevenueFilters
	
	#region NewRevenueQuery
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="NewRevenueParameterBuilder"/> class
	/// that is used exclusively with a <see cref="NewRevenue"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class NewRevenueQuery : NewRevenueParameterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the NewRevenueQuery class.
		/// </summary>
		public NewRevenueQuery() : base() { }

		/// <summary>
		/// Initializes a new instance of the NewRevenueQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public NewRevenueQuery(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the NewRevenueQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public NewRevenueQuery(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion NewRevenueQuery
		
	#region CreditCardFilters
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="SqlFilterBuilder&lt;EntityColumn&gt;"/> class
	/// that is used exclusively with a <see cref="CreditCard"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class CreditCardFilters : CreditCardFilterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the CreditCardFilters class.
		/// </summary>
		public CreditCardFilters() : base() { }

		/// <summary>
		/// Initializes a new instance of the CreditCardFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public CreditCardFilters(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the CreditCardFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public CreditCardFilters(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion CreditCardFilters
	
	#region CreditCardQuery
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="CreditCardParameterBuilder"/> class
	/// that is used exclusively with a <see cref="CreditCard"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class CreditCardQuery : CreditCardParameterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the CreditCardQuery class.
		/// </summary>
		public CreditCardQuery() : base() { }

		/// <summary>
		/// Initializes a new instance of the CreditCardQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public CreditCardQuery(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the CreditCardQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public CreditCardQuery(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion CreditCardQuery
		
	#region JournalVoucherTypeFilters
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="SqlFilterBuilder&lt;EntityColumn&gt;"/> class
	/// that is used exclusively with a <see cref="JournalVoucherType"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class JournalVoucherTypeFilters : JournalVoucherTypeFilterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the JournalVoucherTypeFilters class.
		/// </summary>
		public JournalVoucherTypeFilters() : base() { }

		/// <summary>
		/// Initializes a new instance of the JournalVoucherTypeFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public JournalVoucherTypeFilters(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the JournalVoucherTypeFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public JournalVoucherTypeFilters(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion JournalVoucherTypeFilters
	
	#region JournalVoucherTypeQuery
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="JournalVoucherTypeParameterBuilder"/> class
	/// that is used exclusively with a <see cref="JournalVoucherType"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class JournalVoucherTypeQuery : JournalVoucherTypeParameterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the JournalVoucherTypeQuery class.
		/// </summary>
		public JournalVoucherTypeQuery() : base() { }

		/// <summary>
		/// Initializes a new instance of the JournalVoucherTypeQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public JournalVoucherTypeQuery(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the JournalVoucherTypeQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public JournalVoucherTypeQuery(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion JournalVoucherTypeQuery
		
	#region DailyTransFilters
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="SqlFilterBuilder&lt;EntityColumn&gt;"/> class
	/// that is used exclusively with a <see cref="DailyTrans"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class DailyTransFilters : DailyTransFilterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the DailyTransFilters class.
		/// </summary>
		public DailyTransFilters() : base() { }

		/// <summary>
		/// Initializes a new instance of the DailyTransFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public DailyTransFilters(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the DailyTransFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public DailyTransFilters(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion DailyTransFilters
	
	#region DailyTransQuery
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="DailyTransParameterBuilder"/> class
	/// that is used exclusively with a <see cref="DailyTrans"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class DailyTransQuery : DailyTransParameterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the DailyTransQuery class.
		/// </summary>
		public DailyTransQuery() : base() { }

		/// <summary>
		/// Initializes a new instance of the DailyTransQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public DailyTransQuery(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the DailyTransQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public DailyTransQuery(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion DailyTransQuery
		
	#region CheckInvoiceFilters
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="SqlFilterBuilder&lt;EntityColumn&gt;"/> class
	/// that is used exclusively with a <see cref="CheckInvoice"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class CheckInvoiceFilters : CheckInvoiceFilterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the CheckInvoiceFilters class.
		/// </summary>
		public CheckInvoiceFilters() : base() { }

		/// <summary>
		/// Initializes a new instance of the CheckInvoiceFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public CheckInvoiceFilters(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the CheckInvoiceFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public CheckInvoiceFilters(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion CheckInvoiceFilters
	
	#region CheckInvoiceQuery
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="CheckInvoiceParameterBuilder"/> class
	/// that is used exclusively with a <see cref="CheckInvoice"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class CheckInvoiceQuery : CheckInvoiceParameterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the CheckInvoiceQuery class.
		/// </summary>
		public CheckInvoiceQuery() : base() { }

		/// <summary>
		/// Initializes a new instance of the CheckInvoiceQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public CheckInvoiceQuery(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the CheckInvoiceQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public CheckInvoiceQuery(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion CheckInvoiceQuery
		
	#region JournalVoucherFilters
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="SqlFilterBuilder&lt;EntityColumn&gt;"/> class
	/// that is used exclusively with a <see cref="JournalVoucher"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class JournalVoucherFilters : JournalVoucherFilterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the JournalVoucherFilters class.
		/// </summary>
		public JournalVoucherFilters() : base() { }

		/// <summary>
		/// Initializes a new instance of the JournalVoucherFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public JournalVoucherFilters(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the JournalVoucherFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public JournalVoucherFilters(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion JournalVoucherFilters
	
	#region JournalVoucherQuery
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="JournalVoucherParameterBuilder"/> class
	/// that is used exclusively with a <see cref="JournalVoucher"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class JournalVoucherQuery : JournalVoucherParameterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the JournalVoucherQuery class.
		/// </summary>
		public JournalVoucherQuery() : base() { }

		/// <summary>
		/// Initializes a new instance of the JournalVoucherQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public JournalVoucherQuery(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the JournalVoucherQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public JournalVoucherQuery(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion JournalVoucherQuery
		
	#region InvoiceCheckingUserFilters
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="SqlFilterBuilder&lt;EntityColumn&gt;"/> class
	/// that is used exclusively with a <see cref="InvoiceCheckingUser"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class InvoiceCheckingUserFilters : InvoiceCheckingUserFilterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the InvoiceCheckingUserFilters class.
		/// </summary>
		public InvoiceCheckingUserFilters() : base() { }

		/// <summary>
		/// Initializes a new instance of the InvoiceCheckingUserFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public InvoiceCheckingUserFilters(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the InvoiceCheckingUserFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public InvoiceCheckingUserFilters(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion InvoiceCheckingUserFilters
	
	#region InvoiceCheckingUserQuery
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="InvoiceCheckingUserParameterBuilder"/> class
	/// that is used exclusively with a <see cref="InvoiceCheckingUser"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class InvoiceCheckingUserQuery : InvoiceCheckingUserParameterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the InvoiceCheckingUserQuery class.
		/// </summary>
		public InvoiceCheckingUserQuery() : base() { }

		/// <summary>
		/// Initializes a new instance of the InvoiceCheckingUserQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public InvoiceCheckingUserQuery(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the InvoiceCheckingUserQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public InvoiceCheckingUserQuery(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion InvoiceCheckingUserQuery
		
	#region TcodeFilters
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="SqlFilterBuilder&lt;EntityColumn&gt;"/> class
	/// that is used exclusively with a <see cref="Tcode"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class TcodeFilters : TcodeFilterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the TcodeFilters class.
		/// </summary>
		public TcodeFilters() : base() { }

		/// <summary>
		/// Initializes a new instance of the TcodeFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public TcodeFilters(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the TcodeFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public TcodeFilters(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion TcodeFilters
	
	#region TcodeQuery
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="TcodeParameterBuilder"/> class
	/// that is used exclusively with a <see cref="Tcode"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class TcodeQuery : TcodeParameterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the TcodeQuery class.
		/// </summary>
		public TcodeQuery() : base() { }

		/// <summary>
		/// Initializes a new instance of the TcodeQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public TcodeQuery(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the TcodeQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public TcodeQuery(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion TcodeQuery
		
	#region JournalDetailsFilters
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="SqlFilterBuilder&lt;EntityColumn&gt;"/> class
	/// that is used exclusively with a <see cref="JournalDetails"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class JournalDetailsFilters : JournalDetailsFilterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the JournalDetailsFilters class.
		/// </summary>
		public JournalDetailsFilters() : base() { }

		/// <summary>
		/// Initializes a new instance of the JournalDetailsFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public JournalDetailsFilters(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the JournalDetailsFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public JournalDetailsFilters(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion JournalDetailsFilters
	
	#region JournalDetailsQuery
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="JournalDetailsParameterBuilder"/> class
	/// that is used exclusively with a <see cref="JournalDetails"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class JournalDetailsQuery : JournalDetailsParameterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the JournalDetailsQuery class.
		/// </summary>
		public JournalDetailsQuery() : base() { }

		/// <summary>
		/// Initializes a new instance of the JournalDetailsQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public JournalDetailsQuery(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the JournalDetailsQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public JournalDetailsQuery(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion JournalDetailsQuery
		
	#region AllInvoiceFilters
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="SqlFilterBuilder&lt;EntityColumn&gt;"/> class
	/// that is used exclusively with a <see cref="AllInvoice"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class AllInvoiceFilters : AllInvoiceFilterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the AllInvoiceFilters class.
		/// </summary>
		public AllInvoiceFilters() : base() { }

		/// <summary>
		/// Initializes a new instance of the AllInvoiceFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public AllInvoiceFilters(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the AllInvoiceFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public AllInvoiceFilters(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion AllInvoiceFilters
	
	#region AllInvoiceQuery
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="AllInvoiceParameterBuilder"/> class
	/// that is used exclusively with a <see cref="AllInvoice"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class AllInvoiceQuery : AllInvoiceParameterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the AllInvoiceQuery class.
		/// </summary>
		public AllInvoiceQuery() : base() { }

		/// <summary>
		/// Initializes a new instance of the AllInvoiceQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public AllInvoiceQuery(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the AllInvoiceQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public AllInvoiceQuery(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion AllInvoiceQuery
		
	#region SunAccountCodeFilters
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="SqlFilterBuilder&lt;EntityColumn&gt;"/> class
	/// that is used exclusively with a <see cref="SunAccountCode"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class SunAccountCodeFilters : SunAccountCodeFilterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the SunAccountCodeFilters class.
		/// </summary>
		public SunAccountCodeFilters() : base() { }

		/// <summary>
		/// Initializes a new instance of the SunAccountCodeFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public SunAccountCodeFilters(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the SunAccountCodeFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public SunAccountCodeFilters(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion SunAccountCodeFilters
	
	#region SunAccountCodeQuery
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="SunAccountCodeParameterBuilder"/> class
	/// that is used exclusively with a <see cref="SunAccountCode"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class SunAccountCodeQuery : SunAccountCodeParameterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the SunAccountCodeQuery class.
		/// </summary>
		public SunAccountCodeQuery() : base() { }

		/// <summary>
		/// Initializes a new instance of the SunAccountCodeQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public SunAccountCodeQuery(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the SunAccountCodeQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public SunAccountCodeQuery(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion SunAccountCodeQuery
		
	#region SunInvoiceFilters
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="SqlFilterBuilder&lt;EntityColumn&gt;"/> class
	/// that is used exclusively with a <see cref="SunInvoice"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class SunInvoiceFilters : SunInvoiceFilterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the SunInvoiceFilters class.
		/// </summary>
		public SunInvoiceFilters() : base() { }

		/// <summary>
		/// Initializes a new instance of the SunInvoiceFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public SunInvoiceFilters(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the SunInvoiceFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public SunInvoiceFilters(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion SunInvoiceFilters
	
	#region SunInvoiceQuery
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="SunInvoiceParameterBuilder"/> class
	/// that is used exclusively with a <see cref="SunInvoice"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class SunInvoiceQuery : SunInvoiceParameterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the SunInvoiceQuery class.
		/// </summary>
		public SunInvoiceQuery() : base() { }

		/// <summary>
		/// Initializes a new instance of the SunInvoiceQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public SunInvoiceQuery(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the SunInvoiceQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public SunInvoiceQuery(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion SunInvoiceQuery
		
	#region SunJournalVoucherFilters
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="SqlFilterBuilder&lt;EntityColumn&gt;"/> class
	/// that is used exclusively with a <see cref="SunJournalVoucher"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class SunJournalVoucherFilters : SunJournalVoucherFilterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the SunJournalVoucherFilters class.
		/// </summary>
		public SunJournalVoucherFilters() : base() { }

		/// <summary>
		/// Initializes a new instance of the SunJournalVoucherFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public SunJournalVoucherFilters(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the SunJournalVoucherFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public SunJournalVoucherFilters(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion SunJournalVoucherFilters
	
	#region SunJournalVoucherQuery
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="SunJournalVoucherParameterBuilder"/> class
	/// that is used exclusively with a <see cref="SunJournalVoucher"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class SunJournalVoucherQuery : SunJournalVoucherParameterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the SunJournalVoucherQuery class.
		/// </summary>
		public SunJournalVoucherQuery() : base() { }

		/// <summary>
		/// Initializes a new instance of the SunJournalVoucherQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public SunJournalVoucherQuery(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the SunJournalVoucherQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public SunJournalVoucherQuery(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion SunJournalVoucherQuery
		
	#region SunPaymentVoucherFilters
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="SqlFilterBuilder&lt;EntityColumn&gt;"/> class
	/// that is used exclusively with a <see cref="SunPaymentVoucher"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class SunPaymentVoucherFilters : SunPaymentVoucherFilterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the SunPaymentVoucherFilters class.
		/// </summary>
		public SunPaymentVoucherFilters() : base() { }

		/// <summary>
		/// Initializes a new instance of the SunPaymentVoucherFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public SunPaymentVoucherFilters(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the SunPaymentVoucherFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public SunPaymentVoucherFilters(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion SunPaymentVoucherFilters
	
	#region SunPaymentVoucherQuery
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="SunPaymentVoucherParameterBuilder"/> class
	/// that is used exclusively with a <see cref="SunPaymentVoucher"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class SunPaymentVoucherQuery : SunPaymentVoucherParameterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the SunPaymentVoucherQuery class.
		/// </summary>
		public SunPaymentVoucherQuery() : base() { }

		/// <summary>
		/// Initializes a new instance of the SunPaymentVoucherQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public SunPaymentVoucherQuery(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the SunPaymentVoucherQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public SunPaymentVoucherQuery(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion SunPaymentVoucherQuery
		
	#region SunReportPrintingFilters
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="SqlFilterBuilder&lt;EntityColumn&gt;"/> class
	/// that is used exclusively with a <see cref="SunReportPrinting"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class SunReportPrintingFilters : SunReportPrintingFilterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the SunReportPrintingFilters class.
		/// </summary>
		public SunReportPrintingFilters() : base() { }

		/// <summary>
		/// Initializes a new instance of the SunReportPrintingFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public SunReportPrintingFilters(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the SunReportPrintingFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public SunReportPrintingFilters(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion SunReportPrintingFilters
	
	#region SunReportPrintingQuery
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="SunReportPrintingParameterBuilder"/> class
	/// that is used exclusively with a <see cref="SunReportPrinting"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class SunReportPrintingQuery : SunReportPrintingParameterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the SunReportPrintingQuery class.
		/// </summary>
		public SunReportPrintingQuery() : base() { }

		/// <summary>
		/// Initializes a new instance of the SunReportPrintingQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public SunReportPrintingQuery(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the SunReportPrintingQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public SunReportPrintingQuery(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion SunReportPrintingQuery
		
	#region VrProcPharRevFilters
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="SqlFilterBuilder&lt;EntityColumn&gt;"/> class
	/// that is used exclusively with a <see cref="VrProcPharRev"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class VrProcPharRevFilters : VrProcPharRevFilterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the VrProcPharRevFilters class.
		/// </summary>
		public VrProcPharRevFilters() : base() { }

		/// <summary>
		/// Initializes a new instance of the VrProcPharRevFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public VrProcPharRevFilters(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the VrProcPharRevFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public VrProcPharRevFilters(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion VrProcPharRevFilters
	
	#region VrProcPharRevQuery
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="VrProcPharRevParameterBuilder"/> class
	/// that is used exclusively with a <see cref="VrProcPharRev"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class VrProcPharRevQuery : VrProcPharRevParameterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the VrProcPharRevQuery class.
		/// </summary>
		public VrProcPharRevQuery() : base() { }

		/// <summary>
		/// Initializes a new instance of the VrProcPharRevQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public VrProcPharRevQuery(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the VrProcPharRevQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public VrProcPharRevQuery(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion VrProcPharRevQuery
	#endregion

	
}
